package com.heihei.serviceimpl.son;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.heihei.common.page.Condition;
import com.heihei.common.page.Query;
import com.heihei.common.response.ResponseVO;
import com.heihei.entity.son.SonSingerEntity;
import com.heihei.enums.DeleteFlagEnum;
import com.heihei.enums.common.SexEnum;
import com.heihei.mapper.son.SonSingerMapper;
import com.heihei.service.son.SonSingerService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
 * 歌手表 服务实现类
 * </p>
 *
 * @author duanhengfei
 * @since 2021-11-29
 */
@Service
public class SonSingerServiceImpl extends ServiceImpl<SonSingerMapper, SonSingerEntity> implements SonSingerService {

    /**
     * 添加
     *
     * @author duanhengfei
     * @date 2021年12月18日 20:43:45
     */
    @Override
    @Transactional
    public ResponseVO<String> myAdd(SonSingerEntity paramEntity) {
        paramEntity.setId(null);
        //歌手性别只能为 0， 1， 2
        //歌手性别如果不传，则默认填充为0  未知
        if(Objects.isNull(paramEntity.getSex())) {
            paramEntity.setSex(SexEnum.UN_KNOW.getKey());
        } else if(!SexEnum.containsKey(paramEntity.getSex())) {
            return ResponseVO.paramIllegal("性别参数有误");
        }
        //歌手名字不能为空，不能重复
        if(StringUtils.isEmpty(paramEntity.getSingerName())) {
            return ResponseVO.paramIllegal("歌手名不能为空");
        }
        List<SonSingerEntity> list = this.list(Wrappers.<SonSingerEntity>lambdaQuery().eq(SonSingerEntity::getSingerName, paramEntity.getSingerName()));
        if(CollectionUtils.isNotEmpty(list)) {
//            return ResponseVO.dealSuccess(list.get(0).getId());
            return ResponseVO.paramIllegal("该歌手已经存在");
        }
        //执行添加操作
        boolean flag = this.save(paramEntity);
        if(!flag) {
            return ResponseVO.dealException("添加可能未成功");
        }
        return ResponseVO.dealSuccess(paramEntity.getId());
    }

    /**
     * 修改
     *
     * @author duanhengfei
     * 2021年12月18日 21:05:50
     */
    @Override
    @Transactional
    public ResponseVO<Boolean> myUpdateById(SonSingerEntity paramEntity) {
        //修改必须传入id
        if(StringUtils.isEmpty(paramEntity.getId())) {
            return ResponseVO.paramLess("请传入要修改元素的主键ID");
        }
        //修改接口不允许删除操作
        paramEntity.setDelFlag(null);
        //判断是否已经删除，或者当前数据库是否存在该记录
        SonSingerEntity currEntity = this.getById(paramEntity.getId());
        if(Objects.isNull(currEntity)) {
            return ResponseVO.paramIllegal("当前记录不存在");
        }
        if(DeleteFlagEnum.DELETED.getKey().equals(currEntity.getDelFlag())) {
            return ResponseVO.paramIllegal("当前记录已被删除");
        }
        //执行修改操作
        boolean flag = this.updateById(paramEntity);
        if(!flag) {
            return ResponseVO.dealException("修改可能未成功");
        }
        return ResponseVO.dealSuccess();
    }

    /**
     * 逻辑删除
     *
     * @author duanhengfei
     * 2021年12月18日 21:15:17
     */
    @Override
    public ResponseVO<Boolean> deleteByIdLogic(String id) {
        if(StringUtils.isEmpty(id)) {
            return ResponseVO.paramLess("请传入要删除的ID");
        }
        SonSingerEntity entity = new SonSingerEntity();
        entity.setId(id);
        entity.setDelFlag(DeleteFlagEnum.DELETED.getKey());
        boolean flag = this.updateById(entity);
        if(!flag) {
            return ResponseVO.paramIllegal("当前记录不存在");
        }
        return ResponseVO.dealSuccess();
    }

    /**
     * 批量删除（逻辑删除）
     *
     * @author duanhengfei
     * 2021年12月18日 21:17:29
     */
    @Override
    public ResponseVO<Boolean> deleteBatch(List<String> idList) {
        if(CollectionUtils.isEmpty(idList)) {
            return ResponseVO.paramLess("请传入要删除的ID");
        }
        List<SonSingerEntity> entityList = idList.stream().map(id -> {
            SonSingerEntity ent = new SonSingerEntity();
            ent.setId(id);
            ent.setDelFlag(DeleteFlagEnum.DELETED.getKey());
            return ent;
        }).collect(Collectors.toList());
        boolean flag = this.updateBatchById(entityList);
        if(!flag) {
            return ResponseVO.paramIllegal("可能不存在对应记录");
        }
        return ResponseVO.dealSuccess();
    }

    /**
     * 列表查询
     *
     * @author duanhengfei
     * 2021年12月18日 21:23:54
     */
    @Override
    public ResponseVO<IPage<SonSingerEntity>> myPageList(SonSingerEntity entityParam, Query query) {
        //根据歌手名称模糊查询、根据歌手国籍模糊查询、根据性别全等查询
        LambdaQueryWrapper<SonSingerEntity> queryWrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotEmpty(entityParam.getSingerName())) {
            queryWrapper.like(SonSingerEntity::getSingerName, entityParam.getSingerName());
        }
        if(StringUtils.isNotEmpty(entityParam.getCountry())) {
            queryWrapper.like(SonSingerEntity::getCountry, entityParam.getCountry());
        }
        if(!Objects.isNull(entityParam.getSex())) {
            queryWrapper.eq(SonSingerEntity::getSex, entityParam.getSex());
        }
        //删除标识，只能为未删除的
        queryWrapper.eq(SonSingerEntity::getDelFlag, DeleteFlagEnum.NOT_DELETED.getKey());
        //执行查询操作
        IPage<SonSingerEntity> dataPageList = this.page(Condition.getPage(query), queryWrapper);
        return ResponseVO.dealSuccess(dataPageList);
    }

    /**
     * 详情
     *
     * @author duanhengfei
     * 2021年12月18日 21:30:21
     */
    @Override
    public ResponseVO<SonSingerEntity> myGetById(String id) {
        if(StringUtils.isEmpty(id)) {
            return ResponseVO.paramLess("请传入要查询的记录主键ID");
        }
        SonSingerEntity entity = this.getById(id);
        if(Objects.isNull(entity)) {
            return ResponseVO.paramIllegal("记录不存在");
        }
        if(DeleteFlagEnum.DELETED.getKey().equals(entity.getDelFlag())) {
            return ResponseVO.paramIllegal("该记录已被删除");
        }
        return ResponseVO.dealSuccess(entity);
    }
}
